home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WWTCLKit / PAThumbWheelCell.m < prev    next >
Encoding:
Text File  |  1995-03-22  |  25.0 KB  |  677 lines
  1. #import "PAThumbWheelCell.h"
  2. //#import "PAThumbWheelCellDrawing.h" // stuck this functionality in here...
  3. #import "PAThumbWheel.h"
  4.  
  5. /******************************************************************************
  6.     PAThumbWheelCell
  7.     
  8. PAThumbWheel offers the functionality of Slider plus the features that you would expect from a real thumbwheel (including 2 3/4 D Graphics!).
  9.  
  10. PAThumbWheel has a linear display mode and a radial display mode and offers the ability to assign a value to the visible region of the control as well as an absolute value that the ThumbWheel will either ignore, bound to or wrap around.
  11.  
  12. PAThumbWheel can also return relative values via its -relativeIntValue & -relativeFloatValue methods. A snap back option allows mouse loops to start from and return to a base value.
  13.  
  14. Copyright 1992, Jeff Martin. (jmartin@next.com 415-780-3833)
  15. ******************************************************************************/
  16. #define PI            3.141592654
  17. #define HALF_PI        1.570796327
  18. #define DEG_TO_RAD 0.0174532925199433        //  PI/180.0
  19. #define SIN(x) (sin(DEG_TO_RAD*(x)))
  20. #define COS(x) (cos(DEG_TO_RAD*(x)))
  21. #define TAN(x) (tan(DEG_TO_RAD*(x)))
  22.  
  23. #define RAD_TO_DEG 57.295779513082320876    //  180.0/PI
  24. #define ASIN(x) (asin(x)*RAD_TO_DEG)
  25. #define ACOS(x) (acos(x)*RAD_TO_DEG)
  26. #define ATAN(x) (atan(x)*RAD_TO_DEG)
  27. // A mod function for floating values
  28. #define MOD(x,y) ((x) - (y)*(int)((float)(x)/(y)))
  29. // Keep 'a' between x and y
  30. #define CLAMP(a,x,y) (MAX((x), MIN((y), (a))))
  31. // Keep 'a' between 'x' and 'y' by wrapping it to the other side
  32. #define CLAMP_WITH_WRAP(a,x,y)                                              \
  33. ( ((a) < (x)) ? ((y) - MOD(((x)-(a)),((y)-(x)))) :                         \
  34. ( ((a) > (y)) ? ((x) + MOD(((a)-(y)),((y)-(x)))) : (a) ) )
  35. // Is a between x and y
  36. #define ISBETWEEN(a,x,y) (((a)>=(x))&&((a)<=(y)))
  37. #define EQUAL(a,b) (ABS((a)-(b))<0.00001)
  38.  
  39. @implementation PAThumbWheelCell
  40.  
  41. // Set reasonable defaults
  42. - init
  43. {
  44.     [super init];
  45.     [self setType:NX_TEXTCELL];
  46.     [self setHorizontal];
  47.  
  48.     [self setLinear]; [self setUnbounded];
  49.     [self setVisibleMax:1.0]; [self setVisibleMin:-1.0];
  50.     [self setAbsoluteMax:2.0]; [self setAbsoluteMin:-2.0];
  51.     [self setSnapsBack:YES]; [self setSnapBackValue:0.0];
  52.     [self setDashInterval:10]; [self setShowMainDash:YES];
  53.     [self setColor:NX_COLORLTGRAY];
  54.     
  55.     [self sendActionOn:NX_MOUSEDOWNMASK|NX_MOUSEDRAGGEDMASK|NX_MOUSEUPMASK];
  56.         colorChanged = NO;
  57.  
  58.     return self;
  59. }
  60.  
  61. - awake
  62. {  colorChanged = NO;
  63.    return [super awake];
  64. }
  65.  
  66. - copyFromZone:(NXZone *)zone
  67. {
  68.   id newCopy = [super copyFromZone:zone];
  69.  
  70.   return newCopy;
  71. }
  72.  
  73.  
  74. // Override trackMouse to provide an infinitely large area(continuous tracking)
  75. - (BOOL)trackMouse:(NXEvent *)event inRect:(const NXRect *)rect ofView:view
  76. { cellFrame = *rect; return [super trackMouse:event inRect:NULL ofView:view]; }
  77.  
  78. // Override to return YES (always track mouse)
  79. - (BOOL)startTrackingAt:(const NXPoint *)startPoint inView:aView { return YES;}
  80.  
  81. // Override from cell to track mouse
  82. - (BOOL)continueTracking:(const NXPoint *)lastPoint 
  83.     at:(const NXPoint *)currPoint inView:view
  84. {
  85.     float currPointVal =[self floatValueAtPoint:*currPoint forFrame:cellFrame];
  86.     float lastPointVal =[self floatValueAtPoint:*lastPoint forFrame:cellFrame];
  87.     float mouseScale = ([NXApp currentEvent]->flags&NX_ALTERNATEMASK)? .1 : 1;
  88.     
  89.     // If TW is bounded and at absolute bound, only track when mouse comes back
  90.     if([self isBounded]) {
  91.         // Return if we are already at absoluteMax and currPoint is greater
  92.         if(EQUAL([self floatValue], [self absoluteMax])) {
  93.             if(currPointVal > [self absoluteMax]) return YES;
  94.             else lastPointVal = [self absoluteMax];
  95.         }
  96.         // Return if we are already at absoluteMin and currPoint is less
  97.         if(EQUAL([self floatValue], [self absoluteMin])) {
  98.             if(currPointVal < [self absoluteMin]) return YES;
  99.             else lastPointVal = [self absoluteMin];
  100.         }
  101.     }
  102.     
  103.     // Set the float value relative to last point
  104.     [self setFloatValue:[self floatValue] + 
  105.         (currPointVal - lastPointVal)*mouseScale];
  106.     
  107.     // Redraw control
  108.     [view display];
  109.     return YES;    // Always continue to track mouse
  110. }
  111.  
  112.  
  113. /******************************************************************************
  114.     floatValueAtPoint:forFrame:
  115.     
  116.     This method gives the value that corresponds to a point with respect to the given frame and the visible range. When in radial mode, the point on the thumbwheel is approximated with a power series for arcCos to get legal values for points outside of the frame.
  117. ******************************************************************************/
  118. - (float)floatValueAtPoint:(NXPoint)point forFrame:(NXRect)frame
  119. {
  120.     float pos = [self isVertical] ? point.y : point.x;
  121.     float base = [self isVertical] ? NX_Y(&frame) : NX_X(&frame);
  122.     float width = [self isVertical] ? NX_HEIGHT(&frame) : NX_WIDTH(&frame);
  123.     float value;
  124.     
  125.     if([self isLinear])
  126.         value = [self visibleMin] + (pos - base)/width*[self visibleRange];
  127.     else {
  128.         float radius = width/2;
  129.         float midP = base + radius;
  130.         float x = (midP - pos)/radius;
  131.         // Get degrees by pwr series approximation of ArcCos (Pi/2 - x - x^3/6)
  132.         float alpha = (HALF_PI - x - x*x*x/6);
  133.         // Convert degrees to TW coords
  134.         value = [self visibleMin] + alpha/PI*[self visibleRange];
  135.     }
  136.     return value;
  137. }
  138.     
  139. // Override from cell to snapback if neccessary
  140. - stopTracking:(const NXPoint *)lastPoint at:(const NXPoint *)stopPoint
  141.     inView:view mouseIsUp:(BOOL)flag
  142. {
  143.     // If the ThumbWheel is in snap back mode, snap it back and redraw
  144.     if([self snapsBack]) {
  145.         [self setFloatValue:[self snapBackValue]];
  146.         [self resetRelativeValue];
  147.         [view display];
  148.     }
  149.     return [super stopTracking:lastPoint at:stopPoint inView:view 
  150.         mouseIsUp:flag];
  151. }
  152.  
  153. // Direction is either DIRECTION_HORIZONTAL or DIRECTION_VERTICAL
  154. - (int)direction { return direction; }
  155. - setDirection:(int)dir
  156. { direction = dir; [image free]; image = NULL; return self; }
  157. - (BOOL)isVertical { return direction == DIRECTION_VERTICAL; }
  158. - setVertical { direction = DIRECTION_VERTICAL; return self; }
  159. - (BOOL)isHorizontal { return direction == DIRECTION_HORIZONTAL; }
  160. - setHorizontal { direction = DIRECTION_HORIZONTAL; return self; }
  161.  
  162. /******************************************************************************
  163.     displayMode, setDisplayMode
  164.     
  165.     The displayMode is either DISPLAY_MODE_LINEAR or DISPLAY_MODE_RADIAL. Linear displays a flat ruler type control whereas radial displays a 3D thumbwheel that actually looks curved .
  166. ******************************************************************************/
  167. - (int)displayMode { return displayMode; }
  168. - setDisplayMode:(int)mode { displayMode = mode; return self; }
  169. - (BOOL)isRadial { return displayMode == DISPLAY_MODE_RADIAL; }
  170. - setRadial { return [self setDisplayMode:DISPLAY_MODE_RADIAL]; }
  171. - (BOOL)isLinear { return displayMode == DISPLAY_MODE_LINEAR; }
  172. - setLinear { return [self setDisplayMode:DISPLAY_MODE_LINEAR]; }
  173.  
  174. /******************************************************************************
  175.     intValue, setIntValue, floatValue, setFloatValue
  176.     
  177.     These methods are overridden to allow us to calculate relative values and to constrain the value with respect to the absolute mode and absolute values.
  178. ******************************************************************************/
  179. - (int)intValue { return (int)[self floatValue]; }
  180. - setIntValue:(int)val { [self setFloatValue:val]; return self; }
  181. - (float)floatValue { return floatValue; }
  182. - setFloatValue:(float)val
  183. { 
  184.     // Clamp or Wrap newValue wrt the absoluteMode
  185.     if(!ISBETWEEN(val, [self absoluteMin], [self absoluteMax])) {
  186.         if([self isBounded]) val = 
  187.             CLAMP(val, [self absoluteMin], [self absoluteMax]);
  188.         else if([self isWrapped]) val = 
  189.             CLAMP_WITH_WRAP(val, [self absoluteMin], [self absoluteMax]);
  190.     }
  191.  
  192.     // Store last float value and set float value
  193.     lastFloatValue = floatValue; floatValue = val;
  194.     return self;
  195. }
  196. - (float)lastFloatValue { return lastFloatValue; }
  197. - setLastFloatValue:(float)value { lastFloatValue=value; return self;}
  198.  
  199. /******************************************************************************
  200.     visibleMax, visibleMin, visibleRange, middleValue
  201.     
  202.     VisibleMax and visibleMin are the values of the thumbwheel at either end; max value is at right/top, min is at left/bottom. middleValue is the value of the TW at the center (wrt visibleMin and visibleMax).
  203. ******************************************************************************/
  204. - (float)visibleMax { return visMax; }
  205. - setVisibleMax:(float)max { visMax = max; return self; }
  206. - (float)visibleMin { return visMin; }
  207. - setVisibleMin:(float)min { visMin = min; return self; }
  208. - (float)visibleRange { return [self visibleMax] - [self visibleMin]; }
  209. - (float)middleValue { return [self visibleMin] + [self visibleRange]/2; }
  210.  
  211. /******************************************************************************
  212.     absoluteMode, absoluteMax, absoluteMin
  213.     
  214.     The absolute mode refers to ThumbWheel values that exceed the visible range. ABSOLUTE_UNBOUNDED means that the TW can be dragged as high or low as desired. ABSOLUTE_BOUNDED means that the TW will be clamped to some arbitrarily large value. ABSOLUTE_WRAPPED means that the TW will wrap from the absoluteMax to the absoluteMin (and vise-versa) when applicable. AbsoluteMax is the value off to the right and up. AbsoluteMin us the value off to the left and down.
  215. ******************************************************************************/
  216. - (int)absoluteMode        { return absMode; }
  217. - setAbsoluteMode:(int)mode { absMode = mode; return self; }
  218. - (BOOL)isUnbounded        { return absMode == ABSOLUTE_UNBOUNDED;  }
  219. - setUnbounded            { return [self setAbsoluteMode:ABSOLUTE_UNBOUNDED]; }
  220. - (BOOL)isBounded         { return absMode == ABSOLUTE_BOUNDED; }
  221. - setBounded            { return [self setAbsoluteMode:ABSOLUTE_BOUNDED]; }
  222. - (BOOL)isWrapped        { return absMode == ABSOLUTE_WRAPPED; }
  223. - setWrapped            { return [self setAbsoluteMode:ABSOLUTE_WRAPPED]; }
  224. - (float)absoluteMax    { return absMax; }
  225. - setAbsoluteMax:(float)value { absMax = value; return self; }
  226. - (float)absoluteMin     { return absMin; }
  227. - setAbsoluteMin:(float)value { absMin = value; return self; }
  228. - (float)absoluteRange    { return [self absoluteMax] - [self absoluteMin]; }
  229.  
  230. /******************************************************************************
  231.     relativeIntValue, relativeFloatValue, resetRelativeValue
  232.     
  233.     These two methods return the change of the value since the last iteration. This is useful for a relative method call ( rotateBy: as opposed to rotateTo:). resetRelativeValue sets the relative change to zero (typically only called internally when snapping back).
  234. ******************************************************************************/
  235. - (int)relativeIntValue
  236. { return [self intValue] - (int)[self lastFloatValue];}
  237. - (float)relativeFloatValue
  238. { return [self floatValue] - [self lastFloatValue]; }
  239. - resetRelativeValue { [self setLastFloatValue:[self floatValue]];return self;}
  240.  
  241. /******************************************************************************
  242.     snapsBack, snapBackValue
  243.     
  244.     It is sometimes useful to have the thumbwheel snap back to some value (zero by default) so that it can be used for relative modification of values (rotate by as opposed to rotateTo:).
  245. ******************************************************************************/
  246. - (BOOL)snapsBack                { return snapsBack; }
  247. - setSnapsBack:(BOOL)flag        { snapsBack = flag; return self; }
  248. - (float)snapBackValue            {return snapBackValue; }
  249. - setSnapBackValue:(float)value    { snapBackValue = value;return self;}
  250.  
  251. /******************************************************************************
  252.     dashInterval, setDashInterval, setDashIntervalEqual
  253.  
  254.      The dash interval is either in degrees (DISPLAY_MODE_RADIAL) or PostScript 
  255. points (DISPLAY_MODE_LINEAR). The default is 10 of each.
  256. ******************************************************************************/
  257. - (float)dashInterval            { return dashInterval; }
  258. - setDashInterval:(float)val
  259. { 
  260.   // wave fixed this.  This was a crasher...
  261.   if (val < 1.0) 
  262.   {  dashInterval = 1.0;
  263.   } 
  264.   else
  265.   {  dashInterval = val;
  266.   }
  267.   return self; 
  268. }
  269.  
  270. /******************************************************************************
  271.     showMainDash, setShowMainDash
  272.  
  273.      The main dash is the dash in the center of the control and gives feedback as to the absolute value of the control. This should be set to NO for TW that only provide relative values.
  274. ******************************************************************************/
  275. - (BOOL)showMainDash             {return showMainDash;}
  276. - setShowMainDash:(BOOL)flag    { showMainDash = flag; return self; }
  277.  
  278. /******************************************************************************
  279.     color, setColor
  280.  
  281.      These methods manipulate the predominant color of the ThumbWheel. Radial ThumbWheel are of course shades of these. The default is NX_COLORLTGRAY. 
  282. ******************************************************************************/
  283. - (NXColor)color            {return color;}
  284. - setColor:(NXColor)c        { color = c; return self; }
  285.  
  286. /******************************************************************************
  287.     shift
  288.     
  289.      The shift is how much the dashes are shifted by to achieve the animation of motion it is in points. It is calculated from the visibleRange and the physicalRange (frame).
  290. ******************************************************************************/
  291. - (int)shift:(const NXRect *)frame
  292. {    
  293.     if([self isLinear]) {
  294.         if([self isHorizontal])
  295.             return (int)(([self floatValue] - [self visibleMin]) / 
  296.                 [self visibleRange]*NX_WIDTH(frame) + .5);
  297.         else
  298.             return (int)(([self floatValue] - [self visibleMin]) / 
  299.                 [self visibleRange]*NX_HEIGHT(frame) +.5);
  300.     }
  301.     else return (int)(([self floatValue] - [self visibleMin])/ 
  302.         [self visibleRange]*180 + .5);
  303. }
  304.  
  305. // Override highlight:inView:lit: so that it does nothing
  306. - highlight:(const NXRect *)frame inView:view lit:(BOOL)flag { return self; }
  307.  
  308. // Override this so that we track mouse whether or not it is on top of us.
  309. + (BOOL)prefersTrackingUntilMouseUp { return YES; }
  310.  
  311.  
  312.  
  313. /******************************************************************************
  314.  
  315.      The Read and Write Methods are for archival.
  316. ******************************************************************************/
  317. - write:(NXTypedStream *)stream
  318. {
  319.     [super write:stream];
  320.  
  321.     NXWriteType(stream, "i", &displayMode);
  322.     NXWriteType(stream, "i", &direction);
  323.  
  324.     NXWriteType(stream, "f", &floatValue);
  325.     NXWriteType(stream, "f", &lastFloatValue);
  326.  
  327.     NXWriteType(stream, "f", &visMax);
  328.     NXWriteType(stream, "f", &visMin);
  329.  
  330.     NXWriteType(stream, "i", &absMode);
  331.     NXWriteType(stream, "f", &absMax);
  332.     NXWriteType(stream, "f", &absMin);
  333.  
  334.     NXWriteType(stream, "c", &snapsBack);
  335.     NXWriteType(stream, "f", &snapBackValue);
  336.  
  337.     NXWriteType(stream, "i", &dashInterval);
  338.     NXWriteType(stream, "c", &showMainDash);
  339.  
  340.     NXWriteColor(stream, color);
  341.     return self;
  342. }
  343.  
  344. - read:(NXTypedStream *)stream
  345. {
  346.     [super read:stream];
  347.  
  348.     NXReadType(stream, "i", &displayMode);
  349.     NXReadType(stream, "i", &direction);
  350.  
  351.  
  352.     NXReadType(stream, "f", &floatValue);
  353.     NXReadType(stream, "f", &lastFloatValue);
  354.  
  355.     NXReadType(stream, "f", &visMax);
  356.     NXReadType(stream, "f", &visMin);
  357.  
  358.     NXReadType(stream, "i", &absMode);
  359.     NXReadType(stream, "f", &absMax);
  360.     NXReadType(stream, "f", &absMin);
  361.  
  362.     NXReadType(stream, "c", &snapsBack);
  363.     NXReadType(stream, "f", &snapBackValue);
  364.  
  365.     NXReadType(stream, "i", &dashInterval);
  366.     NXReadType(stream, "c", &showMainDash);
  367.  
  368.     color = NXReadColor(stream);
  369.         colorChanged = YES;
  370.     return self;
  371. }
  372.  
  373. - free
  374. {
  375.     [image free];
  376.     return [super free];
  377. }
  378.  
  379. // stuff stolen from PAThumbWheelCellDrawing
  380.  
  381. #define NOTEQUAL(a,b) (ABS((a)-(b))>0.0001)
  382. #define EVEN(x) (!(((int)(x))%2))
  383.  
  384. - drawSelf:(const NXRect *)theFrame inView:view
  385. {
  386.     NXRect frame = *theFrame;
  387.     float *pnts;                        // Used for user path of dashes
  388.     char *ops;                            // Used for user path of dashes
  389.     int pntCount, opCount;                // Used for user path of dashes
  390.     float bbox[4] = { NX_X(theFrame), NX_Y(theFrame),
  391.         NX_MAXX(theFrame), NX_MAXY(theFrame) };
  392.     
  393.     // Inset by two to allow for bezeled border
  394.     NXInsetRect(&frame,2,2);
  395.  
  396.     // Draw the background
  397.     if([self isLinear]) {
  398.         NXDrawGrayBezel(theFrame, theFrame);
  399.         NXSetColor(color);
  400.         NXRectFill(&frame);
  401.     }
  402.     else { // if([self isRadial])
  403.         NXSize imageSize;
  404.         [image getSize:&imageSize];
  405.         if(NOTEQUAL(imageSize.width,NX_WIDTH(theFrame)) ||
  406.             NOTEQUAL(imageSize.height,NX_HEIGHT(theFrame)) || colorChanged)
  407.             [self generateImage:theFrame];
  408.         [image composite:NX_COPY toPoint:&theFrame->origin];
  409.     }
  410.     
  411.     // Get the userpath for the dashes
  412.     [self getDashesForFrame:&frame :&pnts :&pntCount :&ops :&opCount];
  413.  
  414.     // Draw dashes once for white part of groove
  415.     if([self isHorizontal]) PStranslate(1,0); else PStranslate(0,-1);
  416.  
  417.     // Draw linear white dashes
  418.     if([self isLinear]) {
  419.         NXSetColor(PAScaleRGBColor(color, 1.5));
  420.         DPSDoUserPath(pnts, pntCount, dps_float, ops, opCount, bbox, 
  421.             dps_ustroke);
  422.     }
  423.     
  424.     // Break up radial white dashes to fade a little bit at ends
  425.     else {
  426.         int i = 0, j = 0, d = [self isHorizontal]? 0 : 1;
  427.         float oneQuarterOfX = [self isHorizontal]? (NX_X(&frame) + 
  428.             NX_WIDTH(&frame)/4) : (NX_Y(&frame) + NX_HEIGHT(&frame)/4);
  429.         float threeQuartersOfX =[self isHorizontal]? (NX_X(&frame) + 
  430.             3*NX_WIDTH(&frame)/4) : (NX_Y(&frame) + 3*NX_HEIGHT(&frame)/4);
  431.  
  432.         NXSetColor(color);
  433.         while((i < pntCount) && (pnts[i+d] < oneQuarterOfX)) i += 4; j = i;
  434.         if(i>0) DPSDoUserPath(pnts, i, dps_float, ops, i/2, bbox, dps_ustroke);
  435.     
  436.         NXSetColor(PAScaleRGBColor(color, 1.5));
  437.         while((j < pntCount) && (pnts[j+d] < threeQuartersOfX)) j+=4;
  438.         if(j>i) DPSDoUserPath(&pnts[i], j-i, dps_float, &ops[i/2], j/2-i/2,
  439.             bbox, dps_ustroke);
  440.     
  441.         NXSetColor(color);
  442.         if(pntCount>j) DPSDoUserPath(&pnts[j], pntCount-j, dps_float, 
  443.             &ops[j/2], opCount-j/2, bbox, dps_ustroke);
  444.     }
  445.     
  446.     if([self isHorizontal]) PStranslate(-1,0); else PStranslate(0,1);
  447.  
  448.     // Draw again for dark part of groove
  449.     if([self isLinear]) NXSetColor(PAScaleRGBColor(color, .5)); 
  450.     else NXSetColor(NX_COLORBLACK);
  451.     DPSDoUserPath(pnts, pntCount, dps_float, ops, opCount, bbox, dps_ustroke);
  452.     
  453.     // If disabled then dim ThumbWheel out
  454.     if(![self isEnabled]) {
  455.         NXSetColor(NX_COLORWHITE); PSsetalpha(.5);
  456.         PScompositerect(NX_X(&frame), NX_Y(&frame), NX_WIDTH(&frame),
  457.             NX_HEIGHT(&frame), NX_SOVER);
  458.     }
  459.     
  460.     // Free user path variables
  461.     free(pnts); free(ops);
  462.     return self;
  463. }
  464.  
  465.  
  466. // wave added these two routines...
  467. - setColorChanged:(BOOL)flag { colorChanged = flag;  return self; }
  468. - (BOOL)colorChanged { return colorChanged; }
  469.  
  470.  
  471. - getDashesForFrame:(const NXRect *)frame :(float **)PNTS :(int *)PNTCOUNT :(char **)OPS :(int *)OPCOUNT
  472. {
  473.     // Get dashInterval and shift
  474.     int dashInt = [self dashInterval];
  475.     int shift = [self shift:frame];
  476.  
  477.     // Calculate how many dashes there will be and alloc space for pnts and ops
  478.     int dashCount = 2 + ([self isRadial] ? 180/dashInt : 
  479.         ([self isVertical] ? NX_HEIGHT(frame) : NX_WIDTH(frame)) / dashInt);
  480.     float *pnts = malloc(sizeof(float)*dashCount*4); // (moveto+lineto)*(x+y)=4
  481.     char *ops     = malloc(sizeof(char)*dashCount*2);  // (moveto+lineto) = 2
  482.     int i=0, j=0;
  483.     
  484.     // Calculate dash sizes
  485.     int dashBase     = [self isVertical] ? NX_X(frame) : NX_Y(frame);
  486.     int dashHeight    = [self isVertical] ? NX_WIDTH(frame) : NX_HEIGHT(frame);
  487.     int dashMinTop     = dashBase + dashHeight*.25;
  488.     int dashMajTop     = dashBase + dashHeight*.5;
  489.     int dashTop        = dashBase + dashHeight;
  490.     
  491.     float base        =    [self isVertical] ? NX_Y(frame) : NX_X(frame);
  492.     float width        =    [self isVertical]? NX_HEIGHT(frame) : NX_WIDTH(frame);
  493.     float halfWidth    =    width/2;
  494.     float mid        =    base + halfWidth;
  495.     float top        =    base + width;
  496.  
  497.     float mainDash;
  498.     float x;
  499.     
  500.     // Calculate whether first dash is a major one. 
  501.     BOOL isMajor    = (shift>=0)? EVEN(shift/dashInt) : !EVEN(shift/dashInt);
  502.         
  503.     // Calculate Linear dashes
  504.     if([self isLinear]) {
  505.         // Set Main dash
  506.         mainDash = base + shift;
  507.  
  508.         // Calculate starting point and set the dashes
  509.         x = base+CLAMP_WITH_WRAP(shift,0,dashInt)%((shift>=0)? dashInt:999999);
  510.         if([self isVertical]) while(x<top) {
  511.             pnts[i++] = dashBase; pnts[i++] = x;
  512.             pnts[i++] = isMajor ? dashMajTop : dashMinTop;
  513.             if(EQUAL(x, mainDash)&&[self showMainDash]) pnts[i-1] = dashTop;
  514.             pnts[i++] = x;
  515.             x += dashInt; isMajor = !isMajor;
  516.         }
  517.         else while(x<top) {
  518.             pnts[i++] = x; pnts[i++] = dashBase;
  519.             pnts[i++] = x; pnts[i++] = isMajor ? dashMajTop : dashMinTop;
  520.             if(EQUAL(x, mainDash)&&[self showMainDash]) pnts[i-1] = dashTop;
  521.             x += dashInt; isMajor = !isMajor;
  522.         }
  523.     }
  524.  
  525.     // Calculate Radial Dashes
  526.     else {
  527.         // This is used to convert the degrees of a dash to a location(in pnts)
  528.         float linDash = 0;
  529.         
  530.         // Inset dash size for beveled edges
  531.         dashBase++; dashTop--;
  532.         
  533.         // Calc Main dash if we show it and it is in sight
  534.         mainDash = mid - IntCos(shift)*halfWidth;
  535.  
  536.         // Calculate the starting point and set the dashes
  537.         x = CLAMP_WITH_WRAP(shift, 0, dashInt)%((shift>=0)? dashInt:999999);
  538.         if([self isVertical]) while(x<180) {
  539.             linDash = mid - IntCos(x)*halfWidth;
  540.             pnts[i++] = dashBase; pnts[i++] = linDash;
  541.             pnts[i++] = isMajor ? dashMajTop : dashMinTop;
  542.             // Check to see if this is a valid main dash
  543.             if(isMajor && EQUAL(linDash,mainDash) && [self showMainDash] &&
  544.                 ISBETWEEN(shift, 0, 180)) pnts[i-1]=dashTop;
  545.             pnts[i++] = linDash;
  546.             x += dashInt; isMajor = !isMajor;
  547.         }
  548.         else while(x<180) {
  549.             linDash = mid - IntCos(x)*halfWidth;
  550.             pnts[i++] = linDash; pnts[i++] = dashBase;
  551.             pnts[i++] = linDash; pnts[i++] = isMajor ? dashMajTop : dashMinTop;
  552.             // Check to see if this is a valid main dash
  553.             if(isMajor && EQUAL(linDash,mainDash) && [self showMainDash] &&
  554.                 ISBETWEEN(shift, 0, 180)) pnts[i-1]=dashTop;
  555.             x += dashInt; isMajor = !isMajor;
  556.         }
  557.     }
  558.         
  559.     // fill the ops array with dps_moveto and dps_lineto
  560.     while(j<i/2) { ops[j++] = dps_moveto; ops[j++] = dps_lineto; }
  561.      
  562.     // Set the passed in pointers to the arrays and the counts and return
  563.     *PNTS = pnts; *OPS = ops; *PNTCOUNT = i; *OPCOUNT = j;
  564.     return self;
  565. }
  566.  
  567. - generateImage:(const NXRect *)theFrame
  568. {
  569.     float circleHeight;
  570.     float x, rad, rad2, mid;
  571.     NXRect frame = *theFrame;
  572.  
  573.     if(!image) image = [[NXImage alloc] init];
  574.     [image setSize:&frame.size];
  575.     [image lockFocus];
  576.     NXDrawGrayBezel(&frame,&frame);
  577.     NXInsetRect(&frame,2,2);
  578.     PSsetlinewidth(0.0); 
  579.  
  580.     // Draw horizonal version
  581.     if(direction == DIRECTION_HORIZONTAL) {
  582.         rad = NX_WIDTH(&frame)/2.0; rad2 = rad*rad;
  583.         mid = NX_MIDX(&frame);
  584.  
  585.         for(x = NX_X(&frame); x <= NX_MIDX(&frame); x++) {
  586.             float topx = NX_MAXX(&frame) - (x - NX_X(&frame));
  587.             circleHeight = sqrt(rad2 - (mid-x)*(mid-x))/rad;
  588.  
  589.             PSnewpath();
  590.             NXSetColor(PAScaleRGBColor(color, .5*circleHeight));
  591.             PSmoveto(x, NX_Y(&frame));        PSlineto(x, NX_Y(&frame) + 2);
  592.             PSmoveto(topx, NX_Y(&frame));    PSlineto(topx, NX_Y(&frame) + 2);
  593.             PSstroke();
  594.  
  595.             PSnewpath();
  596.             NXSetColor(PAScaleRGBColor(color, circleHeight));
  597.             PSmoveto(x, NX_Y(&frame)+2);    PSlineto(x, NX_MAXY(&frame) - 1);
  598.             PSmoveto(topx, NX_Y(&frame)+2);PSlineto(topx,NX_MAXY(&frame) -1);
  599.             PSstroke();
  600.  
  601.             PSnewpath();
  602.             NXSetColor(PAScaleRGBColor(color,1.5*circleHeight));
  603.             PSmoveto(x, NX_MAXY(&frame)-1);    PSlineto(x, NX_MAXY(&frame));
  604.             PSmoveto(topx, NX_MAXY(&frame)-1);PSlineto(topx, NX_MAXY(&frame));
  605.             PSstroke();
  606.         }
  607.     }
  608.     else {
  609.         rad = NX_HEIGHT(&frame)/2.0; rad2 = rad*rad;
  610.         mid = NX_MIDY(&frame);
  611.         for(x = NX_Y(&frame); x <= NX_MIDY(&frame); x++) {
  612.             float topx = NX_MAXY(&frame) - (x - NX_Y(&frame));
  613.             circleHeight = sqrt(rad2 - (mid-x)*(mid-x))/rad;
  614.  
  615.             PSnewpath();
  616.             NXSetColor(PAScaleRGBColor(color, 1.5*circleHeight));
  617.             PSmoveto(NX_X(&frame), x);        PSlineto(NX_X(&frame) + 2, x);
  618.             PSmoveto(NX_X(&frame), topx);    PSlineto(NX_X(&frame) + 2, topx);
  619.             PSstroke();
  620.  
  621.             PSnewpath();
  622.             NXSetColor(PAScaleRGBColor(color, circleHeight));
  623.             PSmoveto(NX_X(&frame)+2, x);    PSlineto(NX_MAXX(&frame) - 1, x);
  624.             PSmoveto(NX_X(&frame)+2, topx);    PSlineto(NX_MAXX(&frame) - 1,topx);
  625.             PSstroke();
  626.  
  627.             PSnewpath();
  628.             NXSetColor(PAScaleRGBColor(color, .5*circleHeight));
  629.             PSmoveto(NX_MAXX(&frame)-1, x);    PSlineto(NX_MAXX(&frame), x);
  630.             PSmoveto(NX_MAXX(&frame)-1, topx);PSlineto(NX_MAXX(&frame), topx);
  631.             PSstroke();
  632.         }
  633.     }
  634.  
  635.     [image unlockFocus];
  636.         colorChanged = NO;
  637.     return self;
  638. }
  639.  
  640. - (const char *)getInspectorClassName { return "PAThumbWheelInspector"; }
  641.  
  642. NXColor PAScaleRGBColor(NXColor c, float scale)
  643. { return NXConvertRGBToColor(NXRedComponent(c)*scale, NXGreenComponent(c)*
  644. scale, NXBlueComponent(c)*scale); }
  645.  
  646. float _IntSin[91] ={0, 0.017452406, 0.034899497, 0.052335956, 0.069756474, 
  647.   0.087155743, 0.10452846, 0.12186934, 0.1391731, 
  648.   0.15643447, 0.17364818, 0.190809, 0.20791169, 
  649.   0.22495105, 0.2419219, 0.25881905, 0.27563736, 
  650.   0.2923717, 0.30901699, 0.32556815, 0.34202014, 
  651.   0.35836795, 0.37460659, 0.39073113, 0.40673664, 
  652.   0.42261826, 0.43837115, 0.4539905, 0.46947156, 
  653.   0.48480962, 0.5, 0.51503807, 0.52991926, 0.54463904, 
  654.   0.5591929, 0.57357644, 0.58778525, 0.60181502, 
  655.   0.61566148, 0.62932039, 0.64278761, 0.65605903, 
  656.   0.66913061, 0.68199836, 0.69465837, 0.70710678, 
  657.   0.7193398, 0.7313537, 0.74314483, 0.75470958, 
  658.   0.76604444, 0.77714596, 0.78801075, 0.79863551, 
  659.   0.80901699, 0.81915204, 0.82903757, 0.83867057, 
  660.   0.8480481, 0.8571673, 0.8660254, 0.87461971, 
  661.   0.88294759, 0.89100652, 0.89879405, 0.90630779, 
  662.   0.91354546, 0.92050485, 0.92718385, 0.93358043, 
  663.   0.93969262, 0.94551858, 0.95105652, 0.95630476, 
  664.   0.9612617, 0.96592583, 0.97029573, 0.97437006, 
  665.   0.9781476, 0.98162718, 0.98480775, 0.98768834, 
  666.   0.99026807, 0.99254615, 0.9945219, 0.9961947, 
  667.   0.99756405, 0.99862953, 0.99939083, 0.9998477, 1.};
  668.  
  669. float IntSin(int x)
  670. {
  671.     if(x < 0)   return -IntSin(-x);
  672.     if(x > 180) return -IntSin(x%180);
  673.     if(x > 90)  return  _IntSin[180-x];
  674.     return _IntSin[x];
  675. }
  676. @end
  677.